package com.ticket.system.service.impl;

import java.util.List;
import java.util.stream.Collectors;

import com.ticket.common.exception.base.BaseException;
import com.ticket.common.utils.Const;
import com.ticket.common.utils.DateUtils;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ticket.system.mapper.TYanchuClassifyMapper;
import com.ticket.system.domain.TYanchuClassify;
import com.ticket.system.service.ITYanchuClassifyService;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

/**
 * 分类管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2023-09-27
 */
@Service
public class TYanchuClassifyServiceImpl implements ITYanchuClassifyService 
{
    @Autowired
    private TYanchuClassifyMapper tYanchuClassifyMapper;

    /**
     * 查询分类管理
     * 
     * @param id 分类管理主键
     * @return 分类管理
     */
    @Override
    public TYanchuClassify selectTYanchuClassifyById(Long id)
    {
        return tYanchuClassifyMapper.selectTYanchuClassifyById(id);
    }

    /**
     * 查询分类管理列表
     * 
     * @param tYanchuClassify 分类管理
     * @return 分类管理
     */
    @Override
    public List<TYanchuClassify> selectTYanchuClassifyList(TYanchuClassify tYanchuClassify)
    {
        return tYanchuClassifyMapper.selectTYanchuClassifyList(tYanchuClassify);
    }

    /**
     * 新增分类管理
     * 
     * @param tYanchuClassify 分类管理
     * @return 结果
     */
    @Override
    public int insertTYanchuClassify(TYanchuClassify tYanchuClassify)
    {
        tYanchuClassify.setCreateTime(DateUtils.getNowDate());
        Integer maxOrdreNum = tYanchuClassifyMapper.getMaxOrdreNum();
        if (null == maxOrdreNum){
            tYanchuClassify.setOrderNum(1);
        }else {
            tYanchuClassify.setOrderNum(maxOrdreNum + 1);
        }
        return tYanchuClassifyMapper.insertTYanchuClassify(tYanchuClassify);
    }

    /**
     * 修改分类管理
     * 
     * @param tYanchuClassify 分类管理
     * @return 结果
     */
    @Override
    public int updateTYanchuClassify(TYanchuClassify tYanchuClassify)
    {
        return tYanchuClassifyMapper.updateTYanchuClassify(tYanchuClassify);
    }

    /**
     * 批量删除分类管理
     * 
     * @param ids 需要删除的分类管理主键
     * @return 结果
     */
    @Override
    public int deleteTYanchuClassifyByIds(List<Long> ids)
    {
        Assert.notNull(ids,"缺少传参");
        //判断当前ids内是否存在演出
        List<TYanchuClassify> tYanchuClassifies = tYanchuClassifyMapper.selectTYanchuClassifyByIds(ids);
        if (CollectionUtils.isNotEmpty(tYanchuClassifies)){
            List<TYanchuClassify> collect = tYanchuClassifies.stream().filter(t -> t.getClassifyNum().compareTo(0) > 0).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(collect)){
                throw new BaseException("删除数据中存在演出,不能删除。");
            }
        }
        return tYanchuClassifyMapper.deleteTYanchuClassifyByIds(ids);
    }

    /**
     * 删除分类管理信息
     * 
     * @param id 分类管理主键
     * @return 结果
     */
    @Override
    public int deleteTYanchuClassifyById(Long id)
    {
        return tYanchuClassifyMapper.deleteTYanchuClassifyById(id);
    }

    /**
     * 上移下移
     *
     * @param id
     * @param type
     * @param orderNum
     */
    @Override
    @Transactional(rollbackFor = RuntimeException.class)
    public void upOrDown(Long id, Integer type, Integer orderNum) {
        //获取排序最大最小值
        Integer maxOrderNum = tYanchuClassifyMapper.getMaxOrdreNum();
        Integer minOrderNum = tYanchuClassifyMapper.getMinOrderNum();
        if (Const.ONE.equals(type) && orderNum.equals(minOrderNum)){
            throw new BaseException("已经是第一个,无法上移。");
        }
        if (Const.TWO.equals(type) && orderNum.equals(maxOrderNum)){
            throw new BaseException("已经是最后一个,无法下移。");
        }
        List<TYanchuClassify> tYanchuClassifies = tYanchuClassifyMapper.selectTYanchuClassifyList(new TYanchuClassify());
        if (CollectionUtils.isNotEmpty(tYanchuClassifies)){
            for (int i = 0; i < tYanchuClassifies.size(); i++) {
                if (tYanchuClassifies.get(i).getId().equals(id)){
                    TYanchuClassify classify = tYanchuClassifies.get(i);
                    TYanchuClassify postersUp = new TYanchuClassify();
                    if (Const.ONE.equals(type)) {
                        //上移
                        postersUp = tYanchuClassifies.get(i - 1);
                    }else {
                        //下移
                        postersUp = tYanchuClassifies.get(i + 1);
                    }
                    Integer num = postersUp.getOrderNum();
                    postersUp.setOrderNum(classify.getOrderNum());
                    classify.setOrderNum(num);
                    tYanchuClassifyMapper.updateTYanchuClassify(classify);
                    tYanchuClassifyMapper.updateTYanchuClassify(postersUp);
                    return;
                }
            }
        }
    }
}
